home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Fritz: All Fritz
/
All Fritz.zip
/
All Fritz
/
FILES
/
PROGNG_C
/
TPTC17GS.LZH
/
TPCSCAN.INC
< prev
next >
Wrap
Text File
|
1988-05-03
|
21KB
|
903 lines
(*
* TPTC - Turbo Pascal to C translator
*
* (C) 1988 Samuel H. Smith (rev. 13-Feb-88)
*
*)
(********************************************************************)
(*
* lexical scanner
*
*)
(********************************************************************)
procedure getchar;
{consume the current char and get the next one}
var
stack: char;
begin
if ofs(stack) < minstack then
fatal('Out of stack space');
while (srclevel > 0) and eof(srcfd[srclevel]) do
begin
if not linestart then putline;
putln('/* TPTC: end of '+srcfiles[srclevel]+' */');
if (not redirect) and (not debug) then
writeln(^M,srcfiles[srclevel],'(',srclines[srclevel],')');
close(srcfd[srclevel]);
freemem(inbuf[srclevel],inbufsiz);
dec(srclevel);
statustime := 0;
end;
if (srclevel = 0) and eof(srcfd[srclevel]) then
nextc := '.'
else
{$i-} read(srcfd[srclevel], nextc); {$i+}
if nextc = ^J then
begin
inc(srclines[srclevel]);
inc(srctotal);
mark_time(curtime);
if (curtime >= statustime) or debug then
begin
if debug then
writeln
else
if not redirect then
write(^M);
if debug or not redirect then
write(srcfiles[srclevel],'(',srclines[srclevel],')');
statustime := curtime+statrate;
abortcheck;
end;
end;
end;
(********************************************************************)
function usec: char;
{use up the current character(return it) and get
the next one from the input stream}
var
c: char;
begin
c := nextc;
getchar;
usec := c;
end;
(********************************************************************)
function newc(n: string40): string40;
{replace the current character with a different one and get the next
character from the input stream}
var
c: char;
begin
c := nextc;
getchar;
newc := n;
end;
(********************************************************************)
procedure addc;
{add current character to ltok and consume it}
begin
inc(ltok[0]);
ltok[length(ltok)] := nextc;
getchar;
{ltok := ltok + usec; <--same thing but slower}
end;
(********************************************************************)
procedure concat_tokens;
{concatenate the next token and the current token}
var
cur: string;
begin
cur := ltok;
ltok := nextc;
toktype := unknown;
scan_tok;
ltok := copy(cur,1,length(cur)-1) + copy(ltok,2,255);
ltok[1] := '"';
ltok[length(ltok)] := '"';
toktype := strng;
end;
(********************************************************************)
procedure scan_ident;
{scan an identifier; output is ltok; nextc is first character following
the identifier; toktype = identifier; this is the protocol for all of
the scan_xxxx procedures in the lexical analyzer}
begin
toktype := unknown;
ltok := '';
repeat
case nextc of
'A'..'Z':
begin
if map_lower then
nextc := chr( ord(nextc)+32 );
addc;
end;
'a'..'z', '0'..'9', '_','@':
addc;
else
toktype := identifier;
end;
until toktype = identifier;
end;
(********************************************************************)
procedure scan_preproc;
{scan a tshell preprocessor directive; same syntax as C already}
begin
repeat
puts(nextc);
getchar;
until nextc = ^M;
getchar;
putline;
toktype := unknown;
end;
(********************************************************************)
function numlit(n: integer): anystring;
{convert a number into a character literal if possible}
var
lit: string[6];
{convert an integer into a c style numeric character literal}
function digit(n: integer): char;
(* convert an integer into a hex digit *)
begin
n := n and 15;
if n > 9 then n := n + 7;
digit := chr( n + ord('0') );
end;
begin
lit := '''\?''';
case n of
$07: lit[3] := 'a';
$08: lit[3] := 'b';
$09: lit[3] := 't';
$0a: lit[3] := 'n';
$0b: lit[3] := 'v';
$0c: lit[3] := 'f';
$0d: lit[3] := 'r';
32..126,128..254:
lit := ''''+chr(n)+'''';
else begin
lit := '''\x??''';
lit[4] := digit(n shr 4);
lit[5] := digit(n);
end;
end;
numlit := lit;
toktype := chars;
end;
(********************************************************************)
procedure scan_number;
{scan a number; this also processes #nnn character literals, which are
converted into octal character literals. imbedded periods are processed,
and a special condition is noted for trailing periods. this is needed
for scanning the ".." keyword when used after numbers. an ungetchar
facility would be more general, but isn't needed anywhere else.
in pascal/mt+, #nnn is translated into nnnL }
var
hasdot: boolean;
charlit: boolean;
islong: boolean;
ishex: boolean;
begin
hasdot := false;
islong := false;
charlit := false;
ishex := false;
toktype := number;
(* check for preprocessor directives, character literals or long literals *)
if nextc = '#' then
begin
ltok := '';
if mt_plus then
islong := true
else
charlit := true;
end;
getchar;
(* check for preprocessor directives *)
if tshell and charlit and (nextc >= 'a') and (nextc <= 'z') then
begin
puts('#');
scan_preproc;
end
else
repeat
if (nextc = '-') and (upcase(ltok[length(ltok)]) = 'E') then
addc;
case nextc of
'e','E':
begin
if not ishex then
toktype := realnumber;
addc;
end;
'$':
begin
ishex := true;
addc;
end;
'0'..'9',
'a'..'f','A'..'F':
addc;
'.':
if hasdot then
begin
toktype := number;
if ltok[length(ltok)] = '.' then
begin
ltok[0] := pred(ltok[0]); {remove trailing ., part of ..}
if charlit then
ltok := numlit(htoi(ltok));
extradot := true;
end;
exit;
end
else
begin
hasdot := true;
toktype := realnumber;
addc;
end;
else
begin
if charlit then
begin
ltok := numlit(htoi(ltok));
if (nextc = '''') or (nextc = '^') or (nextc = '#') then
concat_tokens;
exit;
end;
if ltok[1] = '$' then
begin
ltok := '0x' + copy(ltok,2,99);
toktype := number;
end;
if (toktype <> realnumber) and
(islong or (abs(atol(ltok)) > maxint)) then
begin
ltok := ltok + 'L';
toktype := longnumber;
end;
exit;
end;
end;
until true=false;
end;
(********************************************************************)
procedure scan_hat;
{scan tokens starting with ^ - returns ^X as a character literal
corresponding to the specified control character. returns ^ident as
an identifier with the leading ^ intact. also scans ^. and ^[.}
var
c: char;
begin
getchar;
if ((nextc = '.') or (nextc = '[')) and
((ptoktype = identifier) or (ptok[1] = ']')) then
begin
ltok := '^' + usec; {^. or ^[}
exit;
end;
case nextc of
'@','['..'`':
ltok := usec;
'A'..'Z','a'..'z':
begin
ltok := nextc;
scan_ident;
end;
else
exit;
end;
if length(ltok) = 1 then {^c = control char}
begin
ltok := numlit( ord(upcase(ltok[1])) - ord('@') );
if (nextc = '''') or (nextc = '^') or (nextc = '#') then
concat_tokens;
end
else
ltok := '^' + ltok; {^ident = pointer to ident}
end;
(********************************************************************)
procedure scan_dot;
{scans tokens starting with "."; knows about the 'extra dot' condition
that comes up in number scanning. returns a token of either '.' or '..'}
begin
getchar;
if (nextc = '.') or extradot then
begin
ltok := '..';
extradot := false;
end;
if nextc = '.' then
getchar;
end;
(********************************************************************)
procedure scan_string;
{scans a literal string. processes imbedded quotes ala pascal. translates
the string into a C string with the proper escapes on imbedded quotes.
converts single character strings into character constants. these are
sometimes converted back to strings when the parser needs to}
begin
toktype := unknown;
ltok := '"';
getchar;
repeat
case nextc of
^J,^M:
begin
error_message('Closing quote expected (scan_string)');
toktype := strng;
end;
'''':
begin
getchar; {consume the quote}
if nextc = '''' then
addc
{double quotes are coded as a single quote}
else
begin {end of string}
ltok := ltok + '"';
toktype := strng;
end;
end;
'"': ltok := ltok + newc('\"');
'\': ltok := ltok + newc('\\');
else addc;
end;
until toktype = strng;
if length(ltok) = 3 then
begin
ltok[1] := '''';
ltok[3] := '''';
toktype := chars;
end;
{convert string escapes into character escapes}
if ltok = '"\""' then
begin
ltok := '''"''';
toktype := chars;
end
else
if (ltok = '"''"') or (ltok = '''''''') then
begin
ltok := '''\''''';
toktype := chars;
end
else
if (ltok = '"\\"') then
begin
ltok := '''\\''';
toktype := chars;
end;
{allow consecutive control character literals}
if (nextc = '^') or (nextc = '#') then
concat_tokens;
end;
(********************************************************************)
procedure scan_pragma(var isinclude: anystring);
{scans a turbo pascal compiler option and translates it into a comment.
include directive is translated into the #include.
returns with the first non-blank after the pragma}
var
code: anystring;
prag: anystring;
arg: anystring;
procedure scanword(var dest: anystring);
begin
dest := ' '; {insure dest[2] is initialized}
dest := '';
while true do
case nextc of
' ', '*', '}', ',':
exit;
else
begin
dest := dest + upcase(nextc);
getchar;
end;
end;
end;
begin
isinclude := '';
repeat
if nextc = ',' then
newline;
getchar; {consume the $ or ,}
{get the progma code}
scanword(code);
if nextc = ' ' then
begin
getchar;
scanword(arg);
end
else
arg := '';
if code[2] = '+' then
arg := 'ON'
else
if code[2] = '-' then
arg := 'OFF';
prag := '/* '+code[1]+'(' + arg + ')' + ' */';
case code[1] of
'D': if code[2] = 'E' then
prag := '#define '+arg;
'E': if code[2] = 'N' then
prag := '#endif'
else
if code[2] = 'L' then
prag := '#else';
'I': if code[2] = ' ' then
begin
if pos('.',arg) = 0 then
arg := arg + '.PAS';
prag := '#include "' + arg + '" ';
if includeinclude then
begin
prag := '';
isinclude := arg;
end;
end
else
if code[2] = 'F' then
begin
if code[3] = 'N' then
prag := '#ifndef '+arg
else
prag := '#ifdef '+arg;
end;
'U': if code[2] = 'N' then
prag := '#undef '+arg;
end;
puts(prag);
puts(' ');
while nextc = ' ' do
getchar;
until nextc <> ',';
end;
(********************************************************************)
procedure open_include(name: anystring);
begin
if length(name) = 0 then exit;
inc(srctotal);
inc(objtotal);
inc(srclevel);
if srclevel > maxincl then
fatal('Includes nested too deeply');
srcfiles[srclevel] := name;
srclines[srclevel] := 1;
assign(srcfd[srclevel],name);
{$I-} reset(srcfd[srclevel]); {$I+}
if ioresult <> 0 then
begin
dec(srclevel);
ltok := name;
warning('Missing include file');
end
else
begin
if not linestart then putline;
putln('/* TPTC: include '+name+' */');
if maxavail-300 <= inbufsiz then
begin
ltok := name;
fatal('Out of memory');
end;
getmem(inbuf[srclevel],inbufsiz);
SetTextBuf(srcfd[srclevel],inbuf[srclevel]^,inbufsiz);
end;
if debug then
writeln
else
if not redirect then
write(^M,'':40,^M);
statustime := 0;
end;
(********************************************************************)
procedure scan_curlycomment;
{processes a curly-brace enclosed comment}
var
isinclude: anystring;
begin
toktype := comment;
getchar; {consume the open comment}
isinclude := '';
if nextc = '$' then
scan_pragma(isinclude);
if nextc = '}' then
begin
getchar;
open_include(isinclude);
exit;
end;
if pass_comments then
puts(' /* ');
while nextc <> '}' do
begin
if pass_comments then
puts(nextc);
getchar;
end;
if pass_comments then
begin
puts(' */ ');
if nospace then newline;
end;
getchar; {consume the close comment}
open_include(isinclude);
end;
(********************************************************************)
procedure scan_parencomment;
{process a (* enclosed comment}
var
isinclude: anystring;
begin
toktype := comment;
getchar; {consume the *}
isinclude := '';
if nextc = '$' then
scan_pragma(isinclude);
if pass_comments then
puts('/*');
repeat
if pass_comments then
puts(nextc);
if nextc = '*' then
begin
getchar;
if nextc = ')' then
begin
getchar;
if pass_comments then
begin
puts('/ ');
if nospace then putline;
end;
open_include(isinclude);
exit;
end;
end
else
getchar;
until true=false;
end;
(********************************************************************)
procedure scan_blanks;
{scan white space. this procedure sometimes passes whitespace to the
output. it keeps track of the indentation of the current line so it
can be used by newline}
var
valid: boolean;
begin
linestart := false;
delim := '';
valid := false;
repeat
case nextc of
^M: getchar;
^J: begin
if nospace = false then
putline;
delim := '';
linestart := true;
getchar;
end;
' ',^I,^@,^L:
delim := delim + usec;
'#','\':
if linestart and (tshell or (nextc = '\')) then
begin
if nextc = '\' then
getchar;
puts(delim); {pass preprocessor directives}
delim := ''; {without change (single-line only)}
while nextc <> ^M do
begin
puts(nextc);
getchar;
end;
getchar; {consume the cr}
if nextc = ^J then
getchar; {consume the lf}
putline;
end
else
valid := true;
else
valid := true;
end;
until valid;
if linestart then
begin
spaces := delim;
if nospace=false then
puts(spaces);
linestart := true;
end;
end;
(********************************************************************)
procedure scan_tok;
{scans the next lexical token; returns the token in ltok and toktype}
begin
scan_blanks;
toktype := unknown;
ltok := nextc;
case nextc of
'a'..'z',
'_', 'A'..'Z': scan_ident;
'$': scan_number;
'0'..'9': scan_number;
'''': scan_string;
'^': scan_hat;
'#': begin
scan_number;
if toktype = unknown then
scan_tok; {in case of #directive}
end;
'<': begin
getchar;
if (nextc = '>') or (nextc = '=') then
ltok := '<' + usec;
end;
'>': begin
getchar;
if nextc = '=' then
ltok := '>' + usec;
end;
':': begin
getchar;
if nextc = '=' then
ltok := ':' + usec;
end;
'.': scan_dot;
'{': scan_curlycomment;
'(': begin
getchar;
if nextc = '*' then
scan_parencomment;
end;
else getchar; {consume the unknown char}
end;
end;
(********************************************************************)
procedure gettok;
{get the next input token; this is the top level of the lexical analyzer.
it returns ltok, tok(ltok in upper case), toktype. it translates BEGIN
and END into braces; it checks for statement and section keywords}
var
i: integer;
begin
ptoktype := toktype;
ptok := tok;
cursym := nil;
repeat
scan_tok;
until toktype <> comment;
tok := ltok;
if debug then write(' {',ltok,'}');
if toktype = identifier then
begin
cursym := nil;
stoupper(tok);
if (length(tok) = 5) and (tok = 'BEGIN') then
begin
tok := '{';
ltok := tok;
toktype := keyword;
exit;
end
else
if (length(tok) = 3) and (tok = 'END') then
begin
tok := '}';
ltok := tok;
toktype := keyword;
exit;
end;
(* check for statement keywords *)
i := 0;
repeat
inc(i);
if length(tok) = length(keywords[i]) then
if tok[1] = keywords[i][1] then {hack for speed}
if tok = keywords[i] then
toktype := keyword;
until (i = nkeywords) or (toktype = keyword);
(* get symbol table information for this item *)
cursym := locatesym(tok);
end;
end;
(********************************************************************)
function usetok: string80;
{return (use) and consume current token}
var
tv: string80;
begin
tv := ltok;
gettok;
usetok := tv;
end;